#include "Classe_point.h"
// Library standard
#include <iostream> // entree / sortie
#include <cmath> // pour les fonctions mathematiques

Point::Point() { // Point::Point() : _x(0.0), _y(0.0) { std::cout << "Appel du constructeur par defaut" << std::endl; }
  this->_x = 0.0;
  this->_y = 0.0;

  this->norme = 0.0;

  /*
   * L'instruction suivante permet de savoir à quel constructeur nous faisons appel.
   * Ce message sera affiche a chaque fois qu'un nouvel objet sera declare avec ce 
   * constructeur.
   */
  
  std::cout << "Appel du constructeur par defaut" << std::endl;
}

Point::~Point() {
  /*
   * Aucune action n'est necessaire dans le destructeur puisque aucune allocation
   * dynamique ou action particulière d'initialialisation d'autres classes n'a été faite.
   */
  std::cout << "Appel du destructeur" << std::endl;
}

Point::Point(const double val_x, const double val_y) {
  this->_x = val_x;
  this->_y = val_y;

  //this->norme = std::sqrt( std::pow(val_x, 2.0) + std::pow(val_y, 2.0));
  this->calculNorme(val_x, val_y);

  std::cout << "Appel du constructeur 2" << std::endl;
}

Point::Point(const Point &p) {
  this->_x = p._x;
  this->_y = p._y;
  this->norme = p.norme;

  std::cout << "Appel du constructeur 3" << std::endl;
}

void Point::setX(const double val) {
  this->_x = val;

  // on recalcule la norme
  //this->norme = std::sqrt( std::pow(val, 2.0) + std::pow(this->_y, 2.0));
  this->calculNorme(val, this->_y);
}

void Point::setY(const double val) {
  this->_y = val;

  // on recalcule la norme
  //this->norme = std::sqrt( std::pow(val, 2.0) + std::pow(this->_x, 2.0));
  this->calculNorme(this->_x, val);
}

double Point::getX(void) const {
  return this->_x;
}

double Point::getY(void) const {
  return this->_y;
}

double Point::getNorme(void) const {
  return this->norme;
}

double Point::distance(const Point &p) const {
  return std::sqrt( std::pow(p._x - this->_x, 2.0) + std::pow(p._y - this->_y, 2.0));
}

void Point::calculNorme(const double x, const double y) {
  // std::cout << x << std::endl;
  // std::cout << y << std::endl;
  // std::cout << std::pow(x, 2.0) << std::endl;
  // std::cout << std::pow(y, 2.0) << std::endl;
  this->norme = std::sqrt( std::pow(x, 2.0) + std::pow(y, 2.0));
}
